#ifndef __M_SERVER_H__
#define __M_SERVER_H__

#include "db.hpp"
#include "matcher.hpp"
#include "online.hpp"
#include "room.hpp"
#include "session.hpp"
#include "util.hpp"

// web根目录
#define WEBROOT "./wwwroot/"
// 默认端口号
static const uint16_t defaultport = 8080;

class gobang_server
{
private:
    std::string _web_root; // 静态根目录 ./wwwroot/   /register.html -> ./wwwroot/register.html
    wsserver_t _wssrv;     // 服务器句柄
    user_table _ut;        // 用户管理模块句柄
    online_manager _om;    // 在线用户管理的句柄
    room_manager _rm;      // 游戏房间管理的句柄
    session_manager _sm;   // session管理的句柄
    matcher_manager _mm;   // 匹配管理的句柄

public:
    // 对成员进行初始化，以及服务器回调函数的设置
    gobang_server(const std::string &host, const std::string &username,
                  const std::string &password, const std::string dbname,
                  const uint16_t &port = 3306, const std::string &webroot = WEBROOT)
        : _web_root(webroot), _ut(host, username, password, dbname, port), _rm(&_ut, &_om),
          _sm(&_wssrv), _mm(&_rm, &_ut, &_om)
    {
        // 设置日志等级
        _wssrv.set_access_channels(websocketpp::log::alevel::none);
        // 初始化asio调度器
        _wssrv.init_asio();
        // 设置地址复用
        _wssrv.set_reuse_addr(true);
        // 4.设置回调函数
        _wssrv.set_http_handler(std::bind(&gobang_server::http_callback, this, std::placeholders::_1));
        _wssrv.set_open_handler(std::bind(&gobang_server::wsopen_callback, this, std::placeholders::_1));
        _wssrv.set_close_handler(std::bind(&gobang_server::wsclose_callback, this, std::placeholders::_1));
        _wssrv.set_message_handler(std::bind(&gobang_server::wsmsg_callback, this, std::placeholders::_1, std::placeholders::_2));
    }

    // 启动服务器
    void start(int port = defaultport)
    {
        // 设置监听端口
        _wssrv.listen(port);
        // 开始获取连接
        _wssrv.start_accept();
        // 启动服务器
        _wssrv.run();
    }

private:
    // 静态资源请求的处理
    void file_handler(wsserver_t::connection_ptr &conn)
    {
        // 1.获取到请求的uri--资源路径，了解客户端请求的页面文件的名称
        websocketpp::http::parser::request req = conn->get_request();
        // 2.组合出文件的实际路径  相对根目录 + uri
        std::string uri = req.get_uri();
        std::string realpath = _web_root + uri;

        // 3.如果请求的是一个目录，增加一个后缀 login.html
        if (realpath.back() == '/')
        {
            realpath += "login.html";
        }

        // 4.读取文件内容
        std::string body;
        bool ret = file_util::read(realpath, body);
        // 4.1文件不存在,读取文件内容失败,则打开404页面,默认打开404页面一定成功
        if (ret == false)
        {
            realpath = _web_root + "404.html";
            file_util::read(realpath, body);
            conn->set_status(websocketpp::http::status_code::not_found);
            conn->set_body(body);
            return;
        }

        // 5.设置响应正文
        conn->set_status(websocketpp::http::status_code::ok);
        conn->set_body(body);
    }

    // http响应函数
    void http_resp(wsserver_t::connection_ptr &conn, bool result,
                   websocketpp::http::status_code::value code,
                   const std::string &reason)
    {
        // 得到json对象
        Json::Value resp_json;
        resp_json["result"] = result;
        resp_json["reason"] = reason;

        // 将json对象进行序列化
        std::string resp_body;
        json_util::serialize(resp_json, resp_body);

        // 设置状态码、正文、头部字段
        conn->set_status(code);
        conn->set_body(resp_body);
        conn->append_header("Content-Type", "application/json");
        return;
    }

    // 用户注册功能请求的处理
    void reg(wsserver_t::connection_ptr &conn)
    {
        // 1.获取请求正文
        websocketpp::http::parser::request req = conn->get_request();
        std::string req_body = conn->get_request_body();
        // 2.对正文进行Json反序列化，得到用户名和密码
        Json::Value log_info;
        bool ret = json_util::deserialize(req_body, log_info);
        if (ret == false)
        {
            DLOG("反序列化注册信息失败");
            return http_resp(conn, false, websocketpp::http::status_code::bad_request, "请求的正文格式错误");
        }

        // 3.进行数据库的用户新增操作
        // 3.1如果用户名和密码至少有一个为空，则返回错误
        if (log_info["username"].isNull() || log_info["password"].isNull())
        {
            DLOG("用户名密码不完整");
            return http_resp(conn, false, websocketpp::http::status_code::bad_request, "请输入用户名/密码");
        }

        // 插入数据
        ret = _ut.insert(log_info);

        // 3.2向数据插入失败
        if (ret == false)
        {
            DLOG("向数据库插入数据失败");
            return http_resp(conn, false, websocketpp::http::status_code::bad_request, "用户名已经被占用");
        }

        // 如果成功了，则返回200
        return http_resp(conn, true, websocketpp::http::status_code::ok, "用户注册成功");
    }

    // 用户登录功能请求的处理
    void login(wsserver_t::connection_ptr &conn)
    {
        // 1.获取请求正文，并进行json反序列化，得到用户名和密码
        websocketpp::http::parser::request req = conn->get_request();
        std::string req_body = conn->get_request_body();

        Json::Value log_info;
        bool ret = json_util::deserialize(req_body, log_info);
        if (ret == false)
        {
            DLOG("反序列化登录信息失败");
            return http_resp(conn, false, websocketpp::http::status_code::bad_request, "请求的正文格式错误");
        }

        // 2.校验正文的完整性，进行数据库的用户信息验证
        // 2.1用户名密码不完整
        if (log_info["username"].isNull() || log_info["password"].isNull())
        {
            DLOG("用户名密码不完整");
            return http_resp(conn, false, websocketpp::http::status_code::bad_request, "请输入完整的用户名密码");
        }

        ret = _ut.login(log_info);

        // 2.2用户密码错误
        if (ret == false)
        {
            DLOG("用户密码错误");
            return http_resp(conn, false, websocketpp::http::status_code::bad_request, "用户密码错误");
        }

        // 3.如果验证成功，则给客户端返回session
        uint64_t uid = log_info["id"].asInt64();
        session_ptr ssp = _sm.create_session(uid, LOGIN);

        // 3.1创建会话失败
        if (ssp.get() == nullptr)
        {
            DLOG("创建会话失败");
            return http_resp(conn, false, websocketpp::http::status_code::internal_server_error, "创建会话失败");
        }

        // 设置过期时间
        _sm.set_session_expire_time(ssp->ssid(), SESSION_TIMEOUT);

        // 4.设置响应头部，Set-Cookie,将sessionid通过cookie返回
        std::string cookie_ssid = "SSID=" + std::to_string(ssp->ssid());
        conn->append_header("Set-Cookie", cookie_ssid);

        return http_resp(conn, true, websocketpp::http::status_code::ok, "用户登录成功");
    }

    // 从cookie中获取ssid
    // cookie的格式如下:
    // Cookie: <cookie-list>Cookie: name=value
    // Cookie:name=value; name2=value2; name3=value3
    // <cookie-list>形式为名称-值对的列表 <cookie-name>=<cookie-value>,列表中的成对由分号和空格('; ')分隔
    bool get_cookie_val(const std::string &cookie, const std::string &key, std::string &val)
    {
        // Cookie: SSID=XXX; path=/;
        // 1.以; 作为间隔，对字符串进行分隔，得到各个单个的cookie信息
        std::string sep = "; ";
        std::vector<std::string> cookie_arr;
        string_util::split(cookie, sep, cookie_arr);

        // 对单个字符串进行以 = 为间隔的分隔，得到key和value
        for (auto &str : cookie_arr)
        {
            std::vector<std::string> tmp_arr;
            string_util::split(str, "=", tmp_arr);
            if (tmp_arr.size() != 2)
            {
                continue;
            }
            if (tmp_arr[0] == key)
            {
                val = tmp_arr[1];
                return true;
            }
        }

        return false;
    }

    // 用户信息获取功能请求的处理
    void info(wsserver_t::connection_ptr &conn)
    {
        // 1.获取请求信息中的Cookie，从Cookie中获取ssid
        std::string cookie_str = conn->get_request_header("Cookie");
        if (cookie_str.empty())
        {
            return http_resp(conn, false, websocketpp::http::status_code::bad_request,
                             "找不到cookie信息,请重新登录");
        }

        // 从Cookie中获取ssid
        std::string ssid_str;

        // SSID=ssid
        bool ret = get_cookie_val(cookie_str, "SSID", ssid_str);
        if (ret == false)
        {
            // ​如果没有cookie，返回错误，没有cookie信息，让用户重新登录
            return http_resp(conn, false, websocketpp::http::status_code::bad_request, "没有找到ssid信息,需要重新登录");
        }

        // 2.在session管理中查找对应的会话信息
        session_ptr ssp = _sm.get_session_by_ssid(std::stol(ssid_str));
        if (ssp.get() == nullptr)
        {
            // ​没有找到session，则认为登录已经过期，需要重新登录
            http_resp(conn, false, websocketpp::http::status_code::bad_request, "没有找到session信息,需要重新登录");
        }

        // 3.从数据库中取出用户信息，进行序列化发送给客户端
        uint64_t uid = ssp->get_user_id();
        Json::Value user_info;
        ret = _ut.select_by_id(uid, user_info);
        if (ret == false)
        {
            // 获取用户信息失败
            http_resp(conn, false, websocketpp::http::status_code::bad_request, "登录过期,请重新登录");
        }

        std::string body;
        json_util::serialize(user_info, body);
        conn->set_body(body);
        conn->append_header("Content-Type", "application/json");
        conn->set_status(websocketpp::http::status_code::ok);

        // 4.刷新session的过期时间
        _sm.set_session_expire_time(ssp->ssid(), SESSION_TIMEOUT);
    }

    // http请求回调处理函数
    void http_callback(websocketpp::connection_hdl hdl)
    {
        // 获取连接
        wsserver_t::connection_ptr conn = _wssrv.get_con_from_hdl(hdl);
        // 从连接中获取请求
        websocketpp::http::parser::request req = conn->get_request();
        // 从请求中获取请求方法和uri
        std::string method = req.get_method();
        std::string uri = req.get_uri();

        // 注册的请求
        if (method == "POST" && uri == "/reg")
        {
            return reg(conn);
        }
        // 登录的请求
        else if (method == "POST" && uri == "/login")
        {
            return login(conn);
        }
        // 获取用户信息的请求
        else if (method == "GET" && uri == "/info")
        {
            return info(conn);
        }
        // 其他的默认为静态资源的请求
        else
        {
            return file_handler(conn);
        }
    }

    void ws_resp(wsserver_t::connection_ptr conn, Json::Value &resp)
    {
        std::string body;
        json_util::serialize(resp, body);
        conn->send(body);
    }

    session_ptr get_session_by_cookie(wsserver_t::connection_ptr conn)
    {
        // 1.获取请求信息中的Cookie,从Cookie中获取ssid
        Json::Value resp_json;
        std::string cookie_str = conn->get_request_header("Cookie");
        if (cookie_str.empty())
        {
            // 如果没有cookie，返回错误：没有cookie信息，让客户端重新登录
            resp_json["optype"] = "hall_ready";
            resp_json["result"] = false;
            resp_json["reason"] = "没有找到cookie信息,请重新登录";
            ws_resp(conn, resp_json);
            return session_ptr();
        }

        // 2.从Cookie中获取ssid
        std::string ssid_str;
        bool ret = get_cookie_val(cookie_str, "SSID", ssid_str);
        if (ret == false)
        {
            // ​如果没有cookie，返回错误，没有cookie信息，让用户重新登录
            resp_json["optype"] = "hall_ready";
            resp_json["result"] = false;
            resp_json["reason"] = "没有找到ssid信息,需要重新登录";
            ws_resp(conn, resp_json);
            return session_ptr();
        }

        // 3.在session管理中查找对应的会话信息
        session_ptr ssp = _sm.get_session_by_ssid(std::stol(ssid_str));
        if (ssp.get() == nullptr)
        {
            resp_json["optype"] = "hall_ready";
            resp_json["result"] = false;
            resp_json["reason"] = "没有找到session信息,需要重新登录";
            ws_resp(conn, resp_json);
            return session_ptr();
        }

        return ssp;
    }

    // 建立游戏大厅的长连接
    void wsopen_game_hall(wsserver_t::connection_ptr conn)
    {
        Json::Value resp_json;
        // 1.登录验证--判断当前用户是否已经成功登录
        session_ptr ssp = get_session_by_cookie(conn);
        if (ssp.get() == nullptr)
        {
            return;
        }

        // 2.判断当前客户端是否重复登录
        if (_om.is_in_game_hall(ssp->get_user_id()) || _om.is_in_game_room(ssp->get_user_id()))
        {
            resp_json["optype"] = "hall_ready";
            resp_json["result"] = false;
            resp_json["reason"] = "玩家重复登录";
            return ws_resp(conn, resp_json);
        }

        // 3.将当前客户端以及连接加入到游戏大厅
        _om.enter_game_hall(ssp->get_user_id(), conn);

        // 4.给客户端响应游戏大厅连接建立成功
        resp_json["optype"] = "hall_ready";
        resp_json["result"] = true;
        ws_resp(conn, resp_json);

        // 5.记得将session设置为永久存在
        _sm.set_session_expire_time(ssp->ssid(), SESSION_FOREVER);
        DLOG("玩家%d的session在游戏大厅中已经被设置为永久存在", ssp->get_user_id());
    }

    // 建立游戏房间的长连接
    void wsopen_game_room(wsserver_t::connection_ptr conn)
    {
        Json::Value resp_json;
        // 1. 获取当前客户端的session
        session_ptr ssp = get_session_by_cookie(conn);
        if (ssp.get() == nullptr)
        {
            return;
        }

        // 2. 当前用户是否已经在在线用户管理的游戏房间或者游戏大厅中---在线用户管理
        if (_om.is_in_game_hall(ssp->get_user_id()) || _om.is_in_game_room(ssp->get_user_id()))
        {
            resp_json["optype"] = "room_ready";
            resp_json["reason"] = "玩家重复登录！";
            resp_json["result"] = false;
            return ws_resp(conn, resp_json);
        }

        // 3. 判断当前用户是否已经创建好了房间 --- 房间管理
        room_ptr rp = _rm.get_room_by_uid(ssp->get_user_id());
        if (rp.get() == nullptr)
        {
            resp_json["optype"] = "room_ready";
            resp_json["reason"] = "没有找到玩家的房间信息";
            resp_json["result"] = false;
            return ws_resp(conn, resp_json);
        }

        // 4. 将当前用户添加到在线用户管理的游戏房间中
        _om.enter_game_room(ssp->get_user_id(), conn);
        DLOG("玩家%d被添加到在线用户管理的游戏房间中", ssp->get_user_id());

        // 5. 将session重新设置为永久存在
        _sm.set_session_expire_time(ssp->ssid(), SESSION_FOREVER);
        DLOG("玩家%d的session在游戏房间中已经被设置为永久存在", ssp->get_user_id());

        // 6. 回复房间准备完毕
        resp_json["optype"] = "room_ready";
        resp_json["result"] = true;
        resp_json["room_id"] = (Json::UInt64)rp->get_room_id();
        resp_json["uid"] = (Json::UInt64)ssp->get_user_id();
        resp_json["white_id"] = (Json::UInt64)rp->get_white_id();
        resp_json["black_id"] = (Json::UInt64)rp->get_black_id();

        return ws_resp(conn, resp_json);
    }

    // websocket握手成功回调处理函数
    void wsopen_callback(websocketpp::connection_hdl hdl)
    {
        wsserver_t::connection_ptr conn = _wssrv.get_con_from_hdl(hdl);
        websocketpp::http::parser::request req = conn->get_request();
        std::string uri = req.get_uri();

        // 建立游戏大厅的长连接
        if (uri == "/hall")
        {
            return wsopen_game_hall(conn);
        }
        // 建立游戏房间的长连接
        else if (uri == "/room")
        {
            return wsopen_game_room(conn);
        }
    }

    // 断开游戏大厅的长连接
    void wsclose_game_hall(wsserver_t::connection_ptr conn)
    {
        Json::Value resp_json;
        // 1.登录验证--判断当前用户是否已经成功登录
        session_ptr ssp = get_session_by_cookie(conn);
        if (ssp.get() == nullptr)
        {
            return;
        }

        // 2.将玩家从游戏大厅中移除
        _om.exit_game_hall(ssp->get_user_id());
        // 3.将session恢复生命周期,设置定时销毁
        _sm.set_session_expire_time(ssp->ssid(), SESSION_TIMEOUT);
    }

    // 断开游戏房间的长连接
    void wsclose_game_room(wsserver_t::connection_ptr conn)
    {
        // 获取会话信息，识别客户端
        session_ptr ssp = get_session_by_cookie(conn);
        if (ssp.get() == nullptr)
        {
            return;
        }

        // 1. 将玩家从在线用户管理中移除
        _om.exit_game_room(ssp->get_user_id());

        // 2. 将玩家从游戏房间中移除，房间中所有用户退出了就会销毁房间
        _rm.remove_room_user(ssp->get_user_id());

        // 3. 将session回复生命周期的管理，设置定时销毁
        _sm.set_session_expire_time(ssp->ssid(), SESSION_TIMEOUT);
    }

    // websocket连接关闭回调处理函数
    void wsclose_callback(websocketpp::connection_hdl hdl)
    {
        wsserver_t::connection_ptr conn = _wssrv.get_con_from_hdl(hdl);
        websocketpp::http::parser::request req = conn->get_request();
        std::string uri = req.get_uri();

        // 断开游戏大厅的长连接
        if (uri == "/hall")
        {
            return wsclose_game_hall(conn);
        }
        // 断开游戏房间的长连接
        else if (uri == "/room")
        {
            return wsclose_game_room(conn);
        }
    }

    // 游戏大厅信息处理
    void wsmsg_game_hall(wsserver_t::connection_ptr conn, wsserver_t::message_ptr msg)
    {
        Json::Value resp_json;
        std::string resp_body;
        // 1.身份验证,当前客户端到底是哪个玩家
        session_ptr ssp = get_session_by_cookie(conn);
        if (ssp.get() == nullptr)
        {
            return;
        }

        // 2.获取请求信息
        std::string req_body = msg->get_payload();
        Json::Value req_json;
        bool ret = json_util::deserialize(req_body, req_json);
        if (ret == false)
        {
            resp_json["result"] = false;
            resp_json["reason"] = "请求信息解析失败";
            return ws_resp(conn, resp_json);
        }

        // 3.对于请求进行处理
        // 3.1开始对战匹配:通过匹配模块,将用户添加到匹配队列中
        if (!req_json["optype"].isNull() && req_json["optype"].asString() == "match_start")
        {
            _mm.add(ssp->get_user_id());
            resp_json["optype"] = "match_start";
            resp_json["result"] = true;
            DLOG("玩家%d开始匹配", ssp->get_user_id());
            return ws_resp(conn, resp_json);
        }

        // 3.2取消对战匹配:通过匹配模块,将用户从匹配队列中移除
        else if (!req_json["optype"].isNull() && req_json["optype"].asString() == "match_stop")
        {
            _mm.del(ssp->get_user_id());
            resp_json["optype"] = "match_stop";
            resp_json["result"] = true;
            DLOG("玩家%d取消匹配", ssp->get_user_id());
            return ws_resp(conn, resp_json);
        }
        // 4.给客户端端响应
        resp_json["optype"] = "unknow";
        resp_json["result"] = false;
        return ws_resp(conn, resp_json);
    }

    // 游戏房间信息处理
    void wsmsg_game_room(wsserver_t::connection_ptr conn, wsserver_t::message_ptr msg)
    {
        Json::Value resp_json;
        // 1. 获取客户端session，识别客户端身份
        session_ptr ssp = get_session_by_cookie(conn);
        if (ssp.get() == nullptr)
        {
            DLOG("房间-没有找到会话信息");
            return;
        }
        // 2. 获取客户端房间信息
        room_ptr rp = _rm.get_room_by_uid(ssp->get_user_id());
        if (rp.get() == nullptr)
        {
            resp_json["optype"] = "unknow";
            resp_json["reason"] = "没有找到玩家的房间信息";
            resp_json["result"] = false;
            DLOG("房间-没有找到玩家房间信息");
            return ws_resp(conn, resp_json);
        }
        // 3. 对消息进行反序列化
        Json::Value req_json;
        std::string req_body = msg->get_payload();
        bool ret = json_util::deserialize(req_body, req_json);
        if (ret == false)
        {
            resp_json["optype"] = "unknow";
            resp_json["reason"] = "请求解析失败";
            resp_json["result"] = false;
            DLOG("房间-反序列化请求失败");
            return ws_resp(conn, resp_json);
        }
        DLOG("房间：收到房间请求，开始处理....");
        // 4. 通过房间模块进行消息请求的处理
        return rp->handle_request(req_json);
    }

    // websocket消息回调处理函数
    void wsmsg_callback(websocketpp::connection_hdl hdl, wsserver_t::message_ptr msg)
    {
        wsserver_t::connection_ptr conn = _wssrv.get_con_from_hdl(hdl);
        websocketpp::http::parser::request req = conn->get_request();
        std::string uri = req.get_uri();

        // 游戏大厅信息处理
        if (uri == "/hall")
        {
            return wsmsg_game_hall(conn, msg);
        }
        // 游戏房间信息处理
        else if (uri == "/room")
        {
            return wsmsg_game_room(conn, msg);
        }
    }
};

#endif
